home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / WAIS / ir / irsearch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-03  |  13.8 KB  |  480 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4.    Brewster@think.com
  5. */
  6.  
  7. /* Looks up words in the inverted file index.
  8.  * Please pardon my novice C code.
  9.  *
  10.  * -brewster
  11.  */
  12.  
  13. /* Important functions:
  14.  * run_search
  15.  * search_for_words
  16.  */
  17.  
  18. /* to do:
  19.  *    handle the null request by answering something.
  20.  *    answer questions that are just "help" and "?"
  21.  *    Handle searches on multiple databases
  22.  */
  23.  
  24. /* changes 5.2.90 HWM
  25.     - changed calls to perror() to calls to panic()
  26.     - made print_best_hits() only print hits w/ non-zero weight
  27.     - made random arrays static instead of reading them in.  
  28.       removed getRandomArray.
  29.     - removed unused variables
  30.   Brewster 7/90 made look_up_word_in_dictionary safer.
  31.   Brewster 7/90 elimiated trailing <lf> on filename and headline table accesses
  32.   HWM 7.12.90 - replaced all calls to panic with error code returns and a log
  33.                 file  
  34.           - added the routine initSearchEngine() which should be called 
  35.             before any other search routine
  36.           - added beFriendly() to give other processes time under 
  37.             multifinder
  38.   JG 5.31.91 - added relevance feedback for line fragments.
  39.   JG 7.8.91  - added doc_id to search_for_words, removed scale_scores.
  40. */
  41.  
  42. #define _search_c
  43.  
  44. #include <ctype.h>
  45.  
  46. #include <string.h>     /* for strlen() */
  47. #ifdef THINK_C
  48. #include <unix.h>         /* for sleep() */
  49. #endif /* think_c */
  50.  
  51. #include "cutil.h"
  52. #include "irfiles.h"
  53. #include "irlex.h"
  54. #include "irext.h"
  55. #include "irsearch.h"
  56. #include "docid.h"
  57. #include <math.h>
  58.  
  59. #define TEST_SEARCH     false    /* set to TRUE to allow printing to console */
  60.  
  61. /*----------------------------------------------------------------------*/
  62.  
  63. static Boolean calcDocLength _AP((hit* theHit,long* lines,long* bytes));
  64.  
  65. static Boolean
  66. calcDocLength(theHit,lines,bytes)
  67. hit* theHit;
  68. long* lines;
  69. long* bytes;
  70. /* Given a hit, open the file and figure out how many bytes and lines
  71.    it contains.  This is not needed by the serial search engine (it
  72.    stores these values in its dictionary.  It is used by the dynamic
  73.    help facility).
  74. */
  75. {
  76.   *lines = theHit->number_of_lines;
  77.  
  78.   /* find the length of the document */
  79.   if(theHit->end_character != 0)
  80.     {
  81.       /* document is not whole file, so size is stored */
  82.       *bytes = theHit->end_character - theHit->start_character;
  83.       return(true);
  84.     }
  85.   else
  86.     {    
  87.       /* whole file, find file length from the file */
  88.       FILE* file = NULL;
  89.       if (((file = s_fopen(theHit->filename, "r")) != NULL) &&
  90.       (s_fseek(file, 0L, SEEK_END) == 0)  &&
  91.       ((*bytes = ftell(file)) != -1))
  92.     { s_fclose(file);
  93.       return(true);        /* we are done, bytes is set */
  94.     }
  95.       else
  96.     { s_fclose(file);
  97.       return(false);    /* something went wrong with the file */
  98.     }
  99.     }
  100. }
  101.  
  102.  
  103.  
  104.  
  105. static long wordDelimiter _AP((long c));
  106.  
  107. static long wordDelimiter(c)
  108. long c;
  109. /* decide if c is a delimiter or not */
  110. { 
  111.   if (isalnum((char)(c & 0xFF)))
  112.     return(NOT_DELIMITER);
  113.   else
  114.     return(IS_DELIMITER);
  115. }
  116.  
  117. boolean search_for_words(words, db, doc_id)
  118.      char* words;
  119.      /* break the string into words (delimited by non-alphanumerics) 
  120.     and repeatedly call 
  121.     search_for_word(). Note that the string is modified in the process!
  122.     XXX could do something interesting to return feedback on which of the seedwords
  123.     was most/least important
  124.     Returns true if successful.
  125.     */
  126.      database *db;
  127.      long doc_id;
  128. {
  129.   char* word = NULL;
  130.   /* printf("words: %s\n", words); */
  131.   word = strtokf(words,wordDelimiter);
  132.   while(word != NULL){
  133.     long dictionary_value;
  134.     /* trim the string if necessary */
  135.     if(strlen(word) > MAX_WORD_LENGTH){
  136.       word[MAX_WORD_LENGTH] = '\0';
  137.     }
  138.     dictionary_value = look_up_word_in_dictionary(string_downcase(word), db);
  139.     if(dictionary_value > 0){
  140.       if(0 != search_word(word, 0L, 0L, 1L, doc_id, dictionary_value, db))
  141.     return(false);
  142.     }
  143.     word = strtokf(NULL,NULL);
  144.     beFriendly();
  145.   } 
  146.   return(true);
  147. }
  148.  
  149. /* gets the next best hit from the search engine and fills in all the slots.
  150.    If the document does not exist, then it gets another, etc.
  151.    It returns 0 if successful */   
  152. long next_best_hit(the_best_hit, db)
  153.      hit *the_best_hit;
  154.      database *db;
  155. {
  156.   document_table_entry doc_entry;
  157.   long ret_value;
  158.   while(1){ /* keep going until we get a good document */
  159.     if(0 != (ret_value = best_hit(&(the_best_hit->document_id), &(the_best_hit->weight))))
  160.       return(ret_value);
  161.     if(the_best_hit->weight <= 0)    /* if we are out of good stuff, return */
  162.       return(1);
  163.     /* fill in the rest of the hit */
  164.     if (read_document_table_entry(&doc_entry,
  165.                   the_best_hit->document_id,
  166.                   db) 
  167.     == true){
  168.       the_best_hit->start_character = doc_entry.start_character;
  169.       the_best_hit->end_character = doc_entry.end_character;
  170.       the_best_hit->document_length = doc_entry.document_length;
  171.       the_best_hit->number_of_lines = doc_entry.number_of_lines;
  172.       sprintf(the_best_hit->date, "%d", doc_entry.date);
  173.       read_filename_table_entry(doc_entry.filename_id, 
  174.                 the_best_hit->filename,
  175.                 the_best_hit->type,
  176.                 NULL,
  177.                 db),
  178.       strncpy(the_best_hit->headline, 
  179.           read_headline_table_entry(doc_entry.headline_id,db),
  180.           MAX_HEADLINE_LEN);
  181.       if(probe_file(the_best_hit->filename))
  182.     return(0);  /* we win */
  183.       else /* we lose */
  184.     {
  185.     waislog(WLOG_HIGH, WLOG_ERROR, 
  186.         "Dangling File %s in database %s.", 
  187.         the_best_hit->filename,
  188.         db->database_file);
  189.     /*
  190.     strncpy(the_best_hit->headline, "***Missing Document***: ",
  191.         MAX_HEADLINE_LEN);
  192.     strncat(the_best_hit->headline,
  193.         read_headline_table_entry(doc_entry.headline_id,db),
  194.         MAX_HEADLINE_LEN - strlen(the_best_hit->headline));
  195.     return(0);
  196.     */
  197.       }
  198.     }
  199.     else {
  200.       waislog(WLOG_HIGH, WLOG_ERROR, 
  201.           "Error reading doc_table_entry for database %s, docid: %ld",
  202.           db->database_file,
  203.           the_best_hit->document_id);
  204.     }
  205.     beFriendly();
  206.   }
  207. }
  208.  
  209. /*----------------------------------------------------------------------*/
  210.  
  211. boolean run_search(aSearch, headers, diags, index_directory, 
  212.            seed_words_used, waisProtocolVersion, headerNum)
  213.      SearchAPDU* aSearch;
  214.      WAISDocumentHeader** headers; /* list of results */
  215.      diagnosticRecord*** diags;  /* list of diagnostics */
  216.      char *index_directory;
  217.      char **seed_words_used;  /* called with enough space */
  218.      long waisProtocolVersion;
  219.      long *headerNum;
  220. /* runs a search on the inverted file index and returns false if it errors 
  221.    in such a way that it can not even make a diagnostic record 
  222.    (should not happen).
  223.    It changes headers with the replies or makes a diagnostic record
  224.  */
  225. { 
  226.   diagnosticRecord* diag = NULL;
  227.   WAISSearch* wais_search = (WAISSearch*)aSearch->Query; /* for convenience */
  228.   char* new_db_name = (aSearch->DatabaseNames == NULL) ?
  229.     merge_pathnames(INFO_DATABASE_NAME, index_directory) : 
  230.   merge_pathnames(aSearch->DatabaseNames[0], index_directory);
  231.   char* dbName = new_db_name;
  232.   database* db;
  233.   long maxRawScore;
  234.   long normalScore;
  235.   char* originName = NULL;
  236.   long i;
  237.   query_parameter_type parameters;
  238.   boolean search_result;
  239.  
  240.   db = openDatabase(new_db_name, false, true);
  241.   if (db == NULL)
  242.     { char msg[MAX_FILENAME_LEN * 2];
  243.       strncpy(msg,"The following database is not available: ",
  244.           MAX_FILENAME_LEN);
  245.       s_strncat(msg,new_db_name,MAX_FILENAME_LEN,MAX_FILENAME_LEN);
  246.       diag = makeDiag(false,D_PermanentSystemError,msg);
  247.       *diags = (diagnosticRecord **)s_realloc(*diags,(size_t)(sizeof(diagnosticRecord*) * 2));
  248.       (*diags)[0] = diag;
  249.       (*diags)[1] = NULL;
  250.       return(false);
  251.     }
  252.  
  253.   {
  254.     DocObj** docs = NULL;
  255.  
  256.     /* read the query */
  257.     docs = wais_search->Docs;
  258.     if(docs != NULL) {
  259.       if(docs[0] != NULL && docs[0]->Type != NULL) {
  260.     long id = -1;
  261.     if(strcmp(docs[0]->Type,"WAIS_NEXT") == 0)
  262.       id = next_docid(anyToString(GetLocalID(docIDFromAny(docs[0]->DocumentID))),
  263.               db);
  264.     else if(strcmp(docs[0]->Type,"WAIS_PREV") == 0)
  265.       id = previous_docid(anyToString(GetLocalID(docIDFromAny(docs[0]->DocumentID))),
  266.                   db);
  267.     if (id > -1) {
  268.       document_table_entry doc_entry;
  269.       hit foo;
  270.       long lines,length;
  271.       DocID* theDocID = NULL;
  272.       char local_id[MAX_FILENAME_LEN + 60]; /* filename, start, end */
  273.       local_id[0] = '\0';
  274.  
  275.       if (read_document_table_entry(&doc_entry, id, db) == true) {
  276.         foo.start_character = doc_entry.start_character;
  277.         foo.end_character = doc_entry.end_character;
  278.         foo.document_length = doc_entry.document_length;
  279.         foo.number_of_lines = doc_entry.number_of_lines;
  280.  
  281.         read_filename_table_entry(doc_entry.filename_id, 
  282.                       foo.filename,
  283.                       foo.type,
  284.                       NULL,
  285.                       db),
  286.         strncpy(foo.headline, 
  287.             read_headline_table_entry(doc_entry.headline_id,db),
  288.             MAX_HEADLINE_LEN);
  289.         sprintf(foo.date, "%d", doc_entry.date);
  290.         sprintf(local_id, "%ld %ld %s", 
  291.             doc_entry.start_character,
  292.             doc_entry.end_character,
  293.             foo.filename);
  294.         
  295.         if (calcDocLength(&(foo),&lines,&length))
  296.           {            /* this document is good, return it */
  297.         char** type = NULL;
  298.         
  299.         if (waisProtocolVersion >= '2')
  300.           { type = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  301.             type[0] = s_strdup(foo.type);
  302.             type[1] = NULL;
  303.           }
  304.         else
  305.           type = NULL;
  306.  
  307.         theDocID = makeDocID();
  308.         theDocID->originalDatabase = stringToAny(dbName);
  309.         theDocID->originalLocalID = stringToAny(local_id);
  310.         headers[(*headerNum)++] = 
  311.           makeWAISDocumentHeader(anyFromDocID(theDocID),
  312.                      UNUSED,
  313.                      -1L,
  314.                      UNUSED,length,lines,
  315.                      type,
  316.                      s_strdup(dbName),
  317.                      s_strdup(foo.date),
  318.                      s_strdup(foo.headline),
  319.                      NULL);
  320.         headers[*headerNum] = NULL;
  321.         freeDocID(theDocID);
  322.         return(true);
  323.           }
  324.         else
  325.           { 
  326.         waislog(WLOG_HIGH, WLOG_ERROR, 
  327.             "document <%ld %ld %s> skipped.",
  328.             doc_entry.start_character,
  329.             doc_entry.end_character,
  330.             foo.filename);
  331.         return(true);
  332.           }
  333.       }
  334.           
  335.     }
  336.       }
  337.     }    
  338.   }
  339.   /* until seed_words_used is supported */
  340.   strcpy(*seed_words_used, wais_search->SeedWords);
  341.  
  342.   /* note that the serial search engine does not do relevance feedback.
  343.      As such, fed back doc-id's are ignored.  In a real system, we might
  344.      want to generate diagnostics if such an id was inappropriate for this
  345.      database (of course the UI should intercept such requests in the first
  346.      place - but...It has no way of knowing what a server can handle!)
  347.      */
  348.  
  349.   parameters.max_hit_retrieved = wais_search->MaxDocumentsRetrieved;
  350.   set_query_parameter(SET_MAX_RETRIEVED_MASK, ¶meters);
  351.  
  352.   search_result = false;
  353.  
  354.  
  355. #ifdef RELEVANCE_FEEDBACK
  356. #define MAX_TEXT_SIZE 10000    /* Maximume size of relevant text */
  357.   {
  358.     WAISDocumentText *doctext, *getData(), *getDocumentText();
  359.     DocObj** docs = NULL;
  360.     DocObj* doc = NULL;
  361.  
  362.     /* read the query */
  363.     docs = wais_search->Docs;
  364.     if(docs != NULL) {
  365.       /* assemble the elements and construct a response */
  366.       for (i = 0, doc = docs[i]; doc != NULL; doc = docs[++i])
  367.     {
  368.       if(doc->Type == NULL ||
  369.          strcmp(doc->Type,"TEXT") == 0 ||
  370.          doc->Type[0] == 0) {
  371.  
  372.         long errorCode;
  373.         doctext = NULL;
  374.  
  375.         if (doc->ChunkCode == CT_line)
  376.           doctext = getDocumentText(doc, dbName, &errorCode);
  377.         else if ((doc->ChunkCode == CT_byte) ||
  378.              (doc->ChunkCode == CT_document))
  379.           doctext = getData(doc, dbName, &errorCode);
  380.         if (doctext != NULL) {
  381.           if(doctext->DocumentText->size > MAX_TEXT_SIZE)
  382.         doctext->DocumentText->bytes[MAX_TEXT_SIZE] = 0;
  383.           search_result |= 
  384.         search_for_words(doctext->DocumentText->bytes, db, 1);
  385.           freeWAISDocumentText(doctext);
  386.         }
  387.       }
  388.     }
  389.     }
  390.   }
  391. #endif                /* RELEVANT_FEEDBACK */
  392.  
  393.   search_result |= search_for_words(wais_search->SeedWords, db, 0);
  394.  
  395.   if (search_result == true)
  396.     {                /* the search went ok */
  397.       hit best_hit;
  398.       originName = dbName;
  399.  
  400.       finished_search_word(db);
  401.       for (i = 0; i < wais_search->MaxDocumentsRetrieved; i++){ 
  402.     if(0 != next_best_hit(&best_hit, db))
  403.       break;        /* out of hits */
  404.     if(i == 0)
  405.       maxRawScore = best_hit.weight;
  406.     if (best_hit.weight > 0){
  407.       long lines,length;
  408.       DocID* theDocID = NULL;
  409.       char local_id[MAX_FILENAME_LEN + 60]; /* filename, start, end */
  410.       local_id[0] = '\0';
  411.  
  412.       if (calcDocLength(&(best_hit),&lines,&length))
  413.         {            /* this document is good, return it */
  414.           char** type = NULL;
  415.           normalScore = (long)floor(
  416.                     (((double)best_hit.weight) /
  417.                      ((double)maxRawScore)) *    
  418.                     (MAX_NORMAL_SCORE + 1));
  419.           if (normalScore > MAX_NORMAL_SCORE)
  420.         normalScore = MAX_NORMAL_SCORE;
  421.  
  422.           sprintf(local_id, "%ld %ld %s", 
  423.               best_hit.start_character,
  424.               best_hit.end_character,
  425.               best_hit.filename);
  426.          
  427.           if (waisProtocolVersion >= '2')
  428.         { type = (char**)s_malloc((size_t)(sizeof(char*) * 2));
  429.           type[0] = s_strdup(best_hit.type);
  430.           type[1] = NULL;
  431.         }
  432.           else
  433.         type = NULL;
  434.           /*
  435.         printf("header %ld out of %ld\n", *headerNum, 
  436.         wais_search->MaxDocumentsRetrieved); 
  437.         */
  438.           theDocID = makeDocID();
  439.           theDocID->originalDatabase = stringToAny(originName);
  440.           theDocID->originalLocalID = stringToAny(local_id);
  441.           headers[(*headerNum)++] = 
  442.         makeWAISDocumentHeader(anyFromDocID(theDocID),
  443.                        UNUSED,
  444.                        (long)normalScore,
  445.                        UNUSED,length,lines,
  446.                        type,
  447.                        s_strdup(originName),
  448.                        s_strdup(best_hit.date),
  449.                        s_strdup(best_hit.
  450.                         headline),
  451.                        NULL);
  452.           headers[*headerNum] = NULL;
  453.           freeDocID(theDocID);
  454.         }
  455.       else
  456.         { 
  457.           waislog(WLOG_HIGH, WLOG_ERROR, 
  458.               "document <%ld %ld %s> skipped.",
  459.               best_hit.start_character,
  460.               best_hit.end_character,
  461.               best_hit.filename);
  462.           return(true);
  463.         }
  464.     }
  465.       }
  466.     }
  467.   else
  468.     {                /* something went awry in the search */
  469.       diag = makeDiag(true,D_PermanentSystemError,
  470.               "Serious error in server");
  471.       *diags = (diagnosticRecord**)s_realloc(*diags,(size_t)(sizeof(diagnosticRecord*) * 2));
  472.       (*diags)[0] = diag;
  473.       (*diags)[1] = NULL;
  474.     }
  475.   finished_best_hit();
  476.   /* free everything */
  477.   closeDatabase(db);
  478.   return(true);
  479. }
  480.